<xi:include href="xml/gdkdrawcontext.xml" />
<xi:include href="xml/gdkglcontext.xml" />
<xi:include href="xml/gdkvulkancontext.xml" />
+ <xi:include href="xml/gdkcairocontext.xml" />
<xi:include href="xml/events.xml" />
<xi:include href="xml/keys.xml" />
<xi:include href="xml/gdkclipboard.xml" />
gdk_display_get_clipboard
gdk_display_get_primary_clipboard
gdk_display_get_setting
+gdk_display_get_startup_notification_id
+gdk_display_setup_window_visual
<SUBSECTION>
gdk_display_map_keyval
<TITLE>Pixbufs</TITLE>
<FILE>pixbufs</FILE>
gdk_pixbuf_get_from_surface
+gdk_pixbuf_get_from_texture
</SECTION>
<SECTION>
gdk_surface_hide
gdk_surface_is_viewable
gdk_surface_get_mapped
-gdk_surface_get_width
-gdk_surface_get_height
gdk_surface_translate_coordinates
gdk_surface_begin_resize_drag
gdk_surface_begin_move_drag
<SUBSECTION>
gdk_surface_set_cursor
gdk_surface_get_cursor
-gdk_surface_set_device_cursor
-gdk_surface_get_device_cursor
gdk_surface_set_input_region
gdk_surface_get_width
gdk_surface_get_height
GdkInputSource
GdkAxisUse
GdkAxisFlags
+GdkDeviceTool
GdkDeviceToolType
GdkDeviceType
-GdkGrabOwnership
<SUBSECTION>
gdk_device_get_name
gdk_device_get_seat
gdk_device_get_num_touches
gdk_device_get_device_tool
+gdk_device_get_caps_lock_state
+gdk_device_get_direction
+gdk_device_get_modifier_state
+gdk_device_get_num_lock_state
+gdk_device_get_scroll_lock_state
+gdk_device_has_bidi_layouts
<SUBSECTION>
gdk_device_get_state
GdkEvent
GdkEventType
GdkEventMask
+GdkKeyMatch
+GdkTouchpadGesturePhase
GdkScrollDirection
GdkCrossingMode
GdkNotifyType
gdk_key_event_get_layout
gdk_key_event_get_level
gdk_key_event_is_modifier
-GdkEventMatch
gdk_key_event_matches
gdk_key_event_get_match
gdk_focus_event_get_in
gdk_touch_event_get_emulating_pointer
gdk_crossing_event_get_mode
gdk_crossing_event_get_detail
+gdk_crossing_event_get_focus
+gdk_grab_broken_event_get_grab_surface
+gdk_dnd_event_get_drop
gdk_configure_event_get_size
gdk_touchpad_event_get_gesture_phase
gdk_touchpad_event_get_n_fingers
gdk_touchpad_event_get_deltas
-gdk_touchpad_pinch_event_get_angle_delta
-gdk_touchpad_pinch_event_get_scale
-gdk_pad_button_event_get_button
-gdk_pad_axis_event_get_value
+gdk_touchpad_event_get_pinch_angle_delta
+gdk_touchpad_event_get_pinch_scale
+gdk_pad_event_get_axis_value
+gdk_pad_event_get_button
gdk_pad_event_get_group_mode
-gdk_drag_event_get_drop
-gdk_grab_broken_event_get_grab_surface
-gdk_event_get_motion_history
+gdk_motion_event_get_history
<SUBSECTION>
gdk_events_get_angle
<FILE>gdkpaintable</FILE>
<TITLE>GdkPaintable</TITLE>
GdkPaintable
+GdkPaintableInterface
GdkPaintableFlags
gdk_paintable_get_current_image
gdk_paintable_snapshot
gdk_paintable_invalidate_size
gdk_paintable_new_empty
-<SUBSECTION Private>
+<SUBSECTION>
+GdkSnapshot
+
+<SUBSECTION Standard>
+GDK_SNAPSHOT
GDK_TYPE_PAINTABLE
+GDK_TYPE_SNAPSHOT
+GDK_IS_SNAPSHOT
+
+<SUBSECTION Private>
+GdkSnapshotClass
gdk_paintable_get_type
+gdk_snapshot_get_type
</SECTION>
<SUBSECTION>
gdk_drag_action_is_unique
+<SUBSECTION>
+GdkDragSurface
+GdkDragSurfaceInterface
+gdk_drag_surface_present
+
<SUBSECTION>
gdk_drop_get_display
gdk_drop_get_device
GDK_TYPE_DROP
GDK_DROP
GDK_IS_DROP
+GDK_TYPE_DRAG_SURFACE
<SUBSECTION Private>
GdkDragClass
gdk_content_provider_new_for_value
gdk_content_provider_new_typed
gdk_content_provider_new_for_bytes
+gdk_content_provider_new_union
gdk_content_provider_ref_formats
gdk_content_provider_ref_storable_formats
gdk_content_provider_content_changed
<xi:include href="xml/api-index-full.xml"><xi:fallback /></xi:include>
</index>
+ <xi:include href="xml/annotation-glossary.xml"><xi:fallback /></xi:include>
+
</book>
<SECTION>
<FILE>GskRenderer</FILE>
+GskRenderer
gsk_renderer_get_surface
gsk_renderer_realize
gsk_renderer_unrealize
GSK_IS_RENDERER
GSK_RENDERER
GSK_TYPE_RENDERER
-GskRenderer
GskRendererClass
gsk_renderer_get_type
GSK_TYPE_SCALING_FILTER
<SECTION>
<FILE>GskRenderNode</FILE>
+GskRenderNode
+GskBlendNode
+GskBlurNode
+GskBorderNode
+GskCairoNode
+GskClipNode
+GskColorMatrixNode
+GskColorNode
+GskContainerNode
+GskCrossFadeNode
+GskDebugNode
+GskInsetShadowNode
+GskLinearGradientNode
+GskOpacityNode
+GskOutsetShadowNode
+GskRepeatingLinearGradientNode
+GskRepeatNode
+GskRoundedClipNode
+GskShadowNode
+GskTextNode
+GskTextureNode
+GskTransformNode
gsk_render_node_ref
gsk_render_node_unref
GskRenderNodeType
gsk_color_node_peek_color
gsk_texture_node_new
gsk_texture_node_get_texture
+GskColorStop
gsk_linear_gradient_node_new
gsk_linear_gradient_node_peek_start
gsk_linear_gradient_node_peek_end
gsk_text_node_peek_font
gsk_text_node_peek_glyphs
gsk_text_node_peek_color
+gsk_text_node_has_color_glyphs
gsk_text_node_get_num_glyphs
gsk_text_node_get_offset
gsk_blur_node_new
GSK_IS_RENDER_NODE
GSK_RENDER_NODE
GSK_TYPE_RENDER_NODE
-GSK_VALUE_HOLDS_RENDER_NODE
-GskRenderNode
+GSK_TYPE_BLEND_NODE
+GSK_TYPE_BLUR_NODE
+GSK_TYPE_BORDER_NODE
+GSK_TYPE_CAIRO_NODE
+GSK_TYPE_CLIP_NODE
+GSK_TYPE_COLOR_MATRIX_NODE
+GSK_TYPE_COLOR_NODE
+GSK_TYPE_CONTAINER_NODE
+GSK_TYPE_CROSS_FADE_NODE
+GSK_TYPE_DEBUG_NODE
+GSK_TYPE_INSET_SHADOW_NODE
+GSK_TYPE_LINEAR_GRADIENT_NODE
+GSK_TYPE_OPACITY_NODE
+GSK_TYPE_OUTSET_SHADOW_NODE
+GSK_TYPE_REPEATING_LINEAR_GRADIENT_NODE
+GSK_TYPE_REPEAT_NODE
+GSK_TYPE_ROUNDED_CLIP_NODE
+GSK_TYPE_SHADOW_NODE
+GSK_TYPE_TEXT_NODE
+GSK_TYPE_TEXTURE_NODE
+GSK_TYPE_TRANSFORM_NODE
GskRenderNodeClass
+gsk_blend_node_get_type
+gsk_blur_node_get_type
+gsk_border_node_get_type
+gsk_broadway_renderer_get_type
+gsk_cairo_node_get_type
+gsk_cairo_renderer_get_type
+gsk_clip_node_get_type
+gsk_color_matrix_node_get_type
+gsk_color_node_get_type
+gsk_container_node_get_type
+gsk_cross_fade_node_get_type
+gsk_debug_node_get_type
+gsk_inset_shadow_node_get_type
+gsk_linear_gradient_node_get_type
+gsk_opacity_node_get_type
+gsk_outset_shadow_node_get_type
gsk_render_node_get_type
+gsk_repeating_linear_gradient_node_get_type
+gsk_repeat_node_get_type
+gsk_rounded_clip_node_get_type
+gsk_shadow_node_get_type
+gsk_text_node_get_type
+gsk_texture_node_get_type
+gsk_transform_node_get_type
GSK_TYPE_BLEND_MODE
<SUBSECTION Standard>
gsk_serialization_error_quark
gsk_transform_transform_point
<SUBSECTION Private>
GSK_TYPE_TRANSFORM
+GSK_TYPE_TRANSFORM_CATEGORY
gsk_transform_get_type
gsk_transform_new
</SECTION>
<para>
You can convert between detailed action names and split-out
- action names and target values using g_action_parse_detailed_action_name()
- and g_action_print_detailed_action_name() but usually you will
+ action names and target values using g_action_parse_detailed_name()
+ and g_action_print_detailed_name() but usually you will
not need to. Most APIs will provide both ways of specifying
actions with targets.
</para>
<xi:include href="xml/gtkdragicon.xml"/>
<xi:include href="xml/gtkdroptarget.xml"/>
<xi:include href="xml/gtkdroptargetasync.xml"/>
+ <xi:include href="xml/gtkdropcontrollermotion.xml"/>
</chapter>
</part>
gtk_center_box_get_type
</SECTION>
-<SECTION>
-<FILE>gtkcenterlayout</FILE>
-<TITLE>GtkCenterLayout</TITLE>
-GtkCenterLayout
-gtk_center_layout_new
-gtk_center_layout_set_start_widget
-gtk_center_layout_set_center_widget
-gtk_center_layout_set_end_widget
-gtk_center_layout_get_start_widget
-gtk_center_layout_get_center_widget
-gtk_center_layout_get_end_widget
-gtk_center_layout_set_baseline_position
-gtk_center_layout_get_baseline_position
-<SUBSECTION Private>
-GTK_TYPE_CENTER_layout
-GTK_CENTER_LAYOUT
-GTK_CENTER_LAYOUT_CLASS
-GTK_IS_CENTER_LAYOUT
-GTK_IS_CENTER_LAYOUT_CLASS
-GTK_CENTER_LAYOUT_GET_CLASS
-<SUBSECTION Private>
-gtk_center_layout_get_type
-</SECTION>
-
<SECTION>
<FILE>gtklistbox</FILE>
<TITLE>GtkListBox</TITLE>
<FILE>gtkbuilder</FILE>
<TITLE>GtkBuilder</TITLE>
GtkBuilder
+GtkBuilderClosureFlags
GtkBuilderError
gtk_builder_new
gtk_builder_new_from_file
<FILE>gtkeditable</FILE>
<TITLE>GtkEditable</TITLE>
GtkEditable
+GtkEditableInterface
+GtkEditableProperties
gtk_editable_get_text
gtk_editable_set_text
gtk_editable_get_chars
<SECTION>
<FILE>gtkfilechoosernative</FILE>
<TITLE>GtkFileChooserNative</TITLE>
+GtkFileChooserNative
gtk_file_chooser_native_new
gtk_file_chooser_native_get_accept_label
gtk_file_chooser_native_set_accept_label
<FILE>gtkfilterlistmodel</FILE>
<TITLE>GtkFilterListModel</TITLE>
GtkFilterListModel
+GtkFilterListModelFilterFunc
gtk_filter_list_model_new
gtk_filter_list_model_new_for_type
gtk_filter_list_model_set_model
gtk_im_context_focus_in
gtk_im_context_focus_out
gtk_im_context_reset
+gtk_im_context_set_client_widget
gtk_im_context_set_cursor_location
gtk_im_context_set_use_preedit
gtk_im_context_set_surrounding
<FILE>gtkscale</FILE>
<TITLE>GtkScale</TITLE>
GtkScale
+GtkScaleFormatValueFunc
gtk_scale_new
gtk_scale_new_with_range
+gtk_scale_set_format_value_func
gtk_scale_set_digits
gtk_scale_set_draw_value
gtk_scale_set_has_origin
gtk_text_buffer_insert_with_tags
gtk_text_buffer_insert_with_tags_by_name
gtk_text_buffer_insert_markup
+gtk_text_buffer_insert_paintable
gtk_text_buffer_delete
gtk_text_buffer_delete_interactive
gtk_text_buffer_backspace
gtk_text_buffer_copy_clipboard
gtk_text_buffer_cut_clipboard
gtk_text_buffer_get_selection_bounds
+gtk_text_buffer_get_selection_content
gtk_text_buffer_begin_user_action
gtk_text_buffer_end_user_action
gtk_text_buffer_add_selection_clipboard
gtk_text_buffer_redo
gtk_text_buffer_begin_irreversible_action
gtk_text_buffer_end_irreversible_action
-gtk_text_buffer_begin_user_action
-gtk_text_buffer_end_user_action
<SUBSECTION Standard>
GTK_TEXT_BUFFER
<SECTION>
<FILE>gtkwidgetpaintable</FILE>
<TITLE>GtkWidgetPaintable</TITLE>
+GtkWidgetPaintable
gtk_widget_paintable_new
gtk_widget_paintable_get_widget
gtk_widget_paintable_set_widget
gtk_widget_get_opacity
gtk_widget_set_opacity
gtk_widget_get_overflow
+GtkOverflow
gtk_widget_set_overflow
gtk_widget_measure
gtk_widget_snapshot_child
<FILE>gtkpopovermenu</FILE>
<TITLE>GtkPopoverMenu</TITLE>
GtkPopoverMenu
+GtkPopoverMenuFlags
gtk_popover_menu_new_from_model
+gtk_popover_menu_new_from_model_full
gtk_popover_menu_set_menu_model
gtk_popover_menu_get_menu_model
GTK_TYPE_POPOVER_MENU
GTK_IS_POPOVER_MENU
GTK_POPOVER_MENU
+GTK_TYPE_POPOVER_MENU_FLAGS
<SUBSECTION Private>
gtk_popover_menu_get_type
<FILE>gtkshortcuttrigger</FILE>
<TITLE>GtkShortcutTrigger</TITLE>
GtkShortcutTrigger
-GtkNeverTrigger
gtk_shortcut_trigger_trigger
gtk_shortcut_trigger_hash
<FILE>gtkshortcutaction</FILE>
<TITLE>GtkShortcutAction</TITLE>
GtkShortcutAction
+GtkShortcutActionFlags
+GtkShortcutFunc
gtk_shortcut_action_to_string
gtk_shortcut_action_print
gtk_shortcut_action_parse_string
<SECTION>
<FILE>gtknative</FILE>
GtkNative
+GtkNativeInterface
gtk_native_get_for_surface
gtk_native_get_surface
gtk_native_get_renderer
gtk_drag_source_get_type
gtk_drawing_area_get_type
gtk_drop_target_get_type
+gtk_drop_target_async_get_type
gtk_editable_get_type
gtk_emoji_chooser_get_type
gtk_entry_buffer_get_type
gtk_message_dialog_get_type
gtk_mount_operation_get_type
gtk_native_get_type
+gtk_native_dialog_get_type
gtk_no_selection_get_type
gtk_notebook_get_type
gtk_notebook_page_get_type
<title>Stop using gdk_pixbuf_get_from_window() and gdk_cairo_set_source_surface()</title>
<para>
These functions are not supported in GTK 4. Instead, either use backend-specific
- APIs, or render your widgets using gtk_widget_render().
+ APIs, or render your widgets using #GtkWidgetClass.snapshot().
</para>
</section>
</para>
<para>
If you need to dismiss a popup when the user clicks outside (the most common
- use for grabs), you can use the GdkSurface #GdkSurface:autohide property instead.
+ use for grabs), you can use the GdkPopup #GdkPopup:autohide property instead.
GtkPopover also has a #GtkPopover:autohide property.
</para>
<para>
If you need to prevent the user from interacting with a window
- while a dialog is open, use #GtkDialog::modal.
+ while a dialog is open, use #GtkWindow:modal on the dialog.
</para>
</section>
In GTK 4, the two roles of a standalone toplevel window
and of a popup that is placed relative to a parent window
have been separated out into two interfaces, #GdkToplevel
- and #GtkPopup.
+ and #GdkPopup.
</para>
<para>
Surfaces implementing these interfaces are created with
gdk_surface_new_toplevel() and gdk_surface_new_popup(),
respectively, and they are presented on screen using
- gtk_toplevel_present() and gdk_popup_present(). The
+ gdk_toplevel_present() and gdk_popup_present(). The
present() functions take parameters in the form of an
auxiliary layout struct, #GdkPopupLayout or
#GdkToplevelLayout.
<section>
<title>Widgets are now visible by default</title>
<para>
- The default value of #GtkWidget::visible in GTK 4 is %TRUE, so you no
+ The default value of #GtkWidget:visible in GTK 4 is %TRUE, so you no
longer need to explicitly show all your widgets. On the flip side, you
need to hide widgets that are not meant to be visible from the start.
</para>
on them.
</para>
<para>
- The function gtk_widget_show_all(), the #GtkWidget::no-show-all property
+ The function gtk_widget_show_all(), the #GtkWidget:no-show-all property
and its getter and setter have been removed in GTK 4, so you should stop using them.
</para>
</section>
<title>Stop using GtkWidget::draw</title>
<para>
The #GtkWidget::draw signal has been removed. Widgets need to implement the
- #GtkWidget::snapshot function now. Connecting draw signal handlers is no longer possible.
+ #GtkWidgetClass.snapshot() function now. Connecting draw signal handlers is no longer possible.
</para>
</section>
<para>
The #GdkSurface functions <function>gdk_surface_iconify()</function>
and <function>gdk_surface_deiconify()</function> have been renamed to
- gdk_surface_minimize() and gdk_surface_unminimize(), respectively.
+ gdk_toplevel_minimize() and gdk_toplevel_present(), respectively.
</para>
<para>
The corresponding #GtkWindow functions <function>gtk_window_iconify()</function>
</para>
<para>
The destination-side DND apis in GTK 4 have also been changed to use and event controller,
- #GTkDropTarget.
+ #GtkDropTarget.
</para>
<para>
Instead of calling gtk_drag_dest_set() and connecting to #GtkWidget signals, you create
connect to #GtkDropTarget signals.
</para>
<para>
- The ::drag-motion signal has been renamed to #GtkDragSource::accept, and instead of
+ The ::drag-motion signal has been renamed to #GtkDropTarget::accept, and instead of
::drag-data-received, you need to use async read methods on the #GdkDrop object, such
- as gdk_drop_read_value_async() or gdk_drop_read_text_async().
+ as gdk_drop_read_async() or gdk_drop_read_value_async().
</para>
</section>
</para></question>
<answer><para>
-Use gtk_snapshot_append_cairo() in your #GtkWidget::snapshot signal handler
-to optain a cairo context and draw with that.
+Use gtk_snapshot_append_cairo() in your #GtkWidgetClass.snapshot() vfunc to optain
+a cairo context and draw with that.
</para>
</answer>
</qandaentry>
</para>
<para>
-Text buffers support undo and redo if gtk_text_buffer_set_undo_enabled()
+Text buffers support undo and redo if gtk_text_buffer_set_enable_undo()
has been set to %TRUE. Use gtk_text_buffer_undo() or gtk_text_buffer_redo()
to perform the necessary action. Note that these operations are ignored if
the buffer is not editable. Developers may want some operations to not be
* gdk_app_launch_context_get_display:
* @context: a #GdkAppLaunchContext
*
- * Gets the #GdkDispolat that @context is for.
+ * Gets the #GdkDisplay that @context is for.
*
* Returns: (transfer none): the display of @context
*/
*
* A #GdkContentFormats describes a set of possible formats content can be
* exchanged in. It is assumed that this set is ordered. #GTypes are more
- * important than mime types. Order between different #Gtypes or mime types
+ * important than mime types. Order between different #GTypes or mime types
* is the order they were added in, most important first. Functions that
* care about order, such as gdk_content_formats_union() will describe in
* their documentation how they interpret that order, though in general the
* gdk_content_provider_content_changed:
* @provider: a #GdkContentProvider
*
- * Emits the #GdkContentProvider::contents-changed signal.
+ * Emits the #GdkContentProvider::content-changed signal.
*/
void
gdk_content_provider_content_changed (GdkContentProvider *provider)
* It is created when a drag is started, and stays alive for duration of
* the DND operation. After a drag has been started with gdk_drag_begin(),
* the caller gets informed about the status of the ongoing drag operation
- * with signals on the #GtkDrag object.
+ * with signals on the #GdkDrag object.
*
* The GdkDrop object represents the target side of an ongoing DND operation.
* Possible drop sites get informed about the status of the ongoing drag operation
* using gdk_event_get_drop().
*
* The actual data transfer is initiated from the target side via an async
- * read, using one of the GdkDrop functions for this purpose: gdk_drop_read_async(),
- * gdk_drop_read_value_async() or gdk_drop_read_text_async().
+ * read, using one of the GdkDrop functions for this purpose: gdk_drop_read_async()
+ * or gdk_drop_read_value_async().
*
* GTK provides a higher level abstraction based on top of these functions,
* and so they are not normally needed in GTK applications. See the
#include "gdkintl.h"
/**
- * SECTION:gdkdragsurface
+ * SECTION:dnd
* @Short_description: Interface for drag surface surfaces
* @Title: Drag surfaces
*
* In this situation, drawing commands may be effecting the contents of a
* @context's surface.
*
- * Returns: %TRUE if the context is between begin_frame() and end_frame() calls.
+ * Returns: %TRUE if the context is between gdk_draw_context_begin_frame()
+ * and gdk_draw_context_end_frame() calls.
*/
gboolean
gdk_draw_context_is_in_frame (GdkDrawContext *context)
*
* Returns the possible actions for this #GdkDrop. If this value
* contains multiple actions - ie gdk_drag_action_is_unique()
- * returns %FALSE for the result - gdk_drag_finish() must choose
+ * returns %FALSE for the result - gdk_drop_finish() must choose
* the action to use when accepting the drop. This will only
* happen if you passed %GDK_ACTION_ASK as one of the possible
* actions in gdk_drag_status(). %GDK_ACTION_ASK itself will not
*
* This value may change over the lifetime of the #GdkDrop both
* as a response to source side actions as well as to calls to
- * gdk_drop_status() or gdk_drag_finish(). The source side will
+ * gdk_drop_status() or gdk_drop_finish(). The source side will
* not change this value anymore once a drop has started.
*
* Returns: The possible #GdkDragActions
* @modifiers: (out): return location for modifiers
*
* Gets a keyval and modifier combination that will cause
- * gdk_event_match() to successfully match the given event.
+ * gdk_key_event_matches() to successfully match the given event.
*
* Returns: %TRUE on success
*/
* gdk_paintable_invalidate_contents() which will emit the
* #GdkPaintable::invalidate-contents signal.
* If a paintable is known to never change its contents, it will set the
- * %GDK_PAINTABLE_STATIC_CONTENT flag. If a consumer cannot deal with changing
+ * %GDK_PAINTABLE_STATIC_CONTENTS flag. If a consumer cannot deal with changing
* contents, it may call gdk_paintable_get_static_image() which will return a
* static paintable and use that.
*
* Unless the contents are invalidated, implementations must guarantee that
* multiple calls to GdkPaintable::snapshot produce the same output.
*
- * This function will emit the GdkPaintable::invalidate-contents signal.
+ * This function will emit the #GdkPaintable::invalidate-contents signal.
*
* If a @paintable reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
* it must not call this function.
* As long as the size is not invalidated, @paintable must return the same values
* for its width, height and intrinsic height.
*
- * This function will emit the GdkPaintable::invalidate-size signal.
+ * This function will emit the #GdkPaintable::invalidate-size signal.
*
* If a @paintable reports the %GDK_PAINTABLE_STATIC_SIZE flag,
* it must not call this function.
* @intrinsic_height: The intrinsic height to report. Can be 0 for no height.
*
* Returns a paintable that has the given intrinsic size and draws nothing.
- * This is often useful for implementing the GdkPaintableClass:get_current_image()
+ * This is often useful for implementing the #GdkPaintableInterface.get_current_image()
* virtual function when the paintable is in an incomplete state (like a
* #GtkMediaStream before receiving the first frame).
*
/**
* GdkPaintableFlags:
* @GDK_PAINTABLE_STATIC_SIZE: The size is immutable.
- * The GdkPaintable::invalidate-size signal will never be
+ * The #GdkPaintable::invalidate-size signal will never be
* emitted.
* @GDK_PAINTABLE_STATIC_CONTENTS: The content is immutable.
- * The GdkPaintable::invalidate-content signal will never be
+ * The #GdkPaintable::invalidate-contents signal will never be
* emitted.
*
* Flags about this object. Implementations use these for optimizations
* snapshot at or 0 if none. This is purely a hint. The object must still
* be able to render at any size.
* @get_intrinsic_aspect_ratio: The preferred aspect ratio for this object
- * or 0 if none. If both GdkPaintable:get_intrinsic_width() and
- * GdkPaintable:get_intrinsic_height() return non-zero values, this function
- * should return the aspect ratio computed from those.
+ * or 0 if none. If both #GdkPaintableInterface.get_intrinsic_width() and
+ * #GdkPaintableInterface.get_intrinsic_height() return non-zero values,
+ * this function should return the aspect ratio computed from those.
*
* The list of functions that can be implemented for the #GdkPaintable interface.
* Note that apart from the first function, no function is mandatory to implement,
- * though it is a good idea to implement GdkPaintable:get_current_image() for
- * non-static paintables and GdkPaintable:get_flags() if the image is not dynamic
- * as the default implementation returns no flags and that will make the
- * implementation likely quite slow.
+ * though it is a good idea to implement #GdkPaintableInterface.get_current_image()
+ * for non-static paintables and #GdkPaintableInterface.get_flags() if the image
+ * is not dynamic as the default implementation returns no flags and that will
+ * make the implementation likely quite slow.
*/
struct _GdkPaintableInterface
{
* otherwise it will change position according to @layout.
*
* After calling this function, the result of the layout can be queried
- * using gdk_popup_get_position(), gdk_surface_get_width(),
- * gdk_surface_get_height(), gdk_popup_get_rect_anchor() and
- * gdk_popup_get_surface_anchor().
+ * using gdk_popup_get_position_x(), gdk_popup_get_position_y(),
+ * gdk_surface_get_width(), gdk_surface_get_height(),
+ * gdk_popup_get_rect_anchor() and gdk_popup_get_surface_anchor().
*
* Presenting may have fail, for example if it was immediately
* hidden if the @popup was set to autohide.
* @cursor: a #GdkCursor
*
* Sets a specific #GdkCursor for a given device when it gets inside @surface.
- * Use gdk_cursor_new_fromm_name() or gdk_cursor_new_from_texture() to create
+ * Use gdk_cursor_new_from_name() or gdk_cursor_new_from_texture() to create
* the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
* %NULL for the @cursor argument to gdk_surface_set_cursor() means that
* @surface will use the cursor of its parent surface. Most surfaces should
* GTK will update this property automatically if
* the @surface background is opaque, as we know where the opaque regions
* are. If your surface background is not opaque, please update this
- * property in your #GtkWidget:css-changed handler.
+ * property in your #GtkWidgetClass.css_changed() handler.
*/
void
gdk_surface_set_opaque_region (GdkSurface *surface,
const graphene_rect_t *bounds);
/**
- * SECTION:gdktexture
+ * SECTION:textures
* @Short_description: Image data for display
* @Title: GdkTexture
*
*
* The Broadway renderer is the default renderer for the broadway backend.
* It will only work with broadway surfaces, otherwise it will fail the
- * call to gdk_renderer_realize().
+ * call to gsk_renderer_realize().
*
* This function is only available when GTK was compiled with Broadway
* support.
/**
* gsk_renderer_render_texture:
- * @renderer: a realized #GdkRenderer
+ * @renderer: a realized #GskRenderer
* @root: a #GskRenderNode
* @viewport: (allow-none): the section to draw or %NULL to use @root's bounds
*
/**
* gsk_shadow_node_peek_shadow:
* @node: (type GskShadowNode): a shadow #GskRenderNode
+ * @i: the given index
*
* Retrieves the shadow data at the given index @i.
*
* dialog. If @system_information is %NULL, the system information
* tab is hidden.
*
- * See #GtkAboutdialog:system-information.
+ * See #GtkAboutDialog:system-information.
*/
void
gtk_about_dialog_set_system_information (GtkAboutDialog *about,
* emitted when they are selected.
*
* To track changes in the selected application, use the
- * #GtkAppChooserbutton::changed signal.
+ * #GtkAppChooserButton::changed signal.
*/
#include "config.h"
* @application: the #GtkApplication which emitted the signal
*
* Emitted when the session manager is about to end the session, only
- * if #GtkApplication::register-session is %TRUE. Applications can
+ * if #GtkApplication:register-session is %TRUE. Applications can
* connect to this signal and call gtk_application_inhibit() with
* %GTK_APPLICATION_INHIBIT_LOGOUT to delay the end of the session
* until state has been saved.
*
* Set this property to %TRUE to register with the session manager.
* This will make GTK+ track the session state (such as the
- * #GtkApplication::screensaver-active property).
+ * #GtkApplication:screensaver-active property).
*/
gtk_application_props[PROP_REGISTER_SESSION] =
g_param_spec_boolean ("register-session",
*
* This property is %TRUE if GTK+ believes that the screensaver is
* currently active. GTK+ only tracks session state (including this)
- * when #GtkApplication::register-session is set to %TRUE.
+ * when #GtkApplication:register-session is set to %TRUE.
*
* Tracking the screensaver state is supported on Linux.
- *
- * Since: 3.24
*/
gtk_application_props[PROP_SCREENSAVER_ACTIVE] =
g_param_spec_boolean ("screensaver-active",
* g_application_id_is_valid().
*
* If no application ID is given then some features (most notably application
- * uniqueness) will be disabled. A null application ID is only allowed with
- * GTK+ 3.6 or later.
+ * uniqueness) will be disabled.
*
* Returns: a new #GtkApplication instance
*/
/**
* gtk_builder_cscope_new:
*
- * Creates a new #GtkbuilderCScope object to use with future #GtkBuilder
+ * Creates a new #GtkBuilderCScope object to use with future #GtkBuilder
* instances.
*
* Calling this function is only necessary if you want to add custom
* @constraint: a #GtkConstraint
*
* Checks whether the @constraint describes a relation between an attribute
- * on the #GtkConstraint:target-widget and a constant value.
+ * on the #GtkConstraint:target and a constant value.
*
* Returns: %TRUE if the constraint is a constant relation
*/
/**
* gtk_constraint_guide_get_min_size:
- * @guide: a #GtkContraintGuide object
+ * @guide: a #GtkConstraintGuide object
* @width: (allow-none): return location for the minimum width,
* or %NULL
* @height: (allow-none): return location for the minimum height,
/**
* gtk_constraint_guide_get_nat_size:
- * @guide: a #GtkContraintGuide object
+ * @guide: a #GtkConstraintGuide object
* @width: (allow-none): return location for the natural width,
* or %NULL
* @height: (allow-none): return location for the natural height,
/**
* gtk_constraint_guide_get_max_size:
- * @guide: a #GtkContraintGuide object
+ * @guide: a #GtkConstraintGuide object
* @width: (allow-none): return location for the maximum width,
* or %NULL
* @height: (allow-none): return location for the maximum height,
/**
* gtk_constraint_layout_remove_guide:
- * @layout: a #GtkConstraintManager
+ * @layout: a #GtkConstraintLayout
* @guide: a #GtkConstraintGuide object
*
* Removes @guide from the layout manager,
* can be used to obtain updates about the status of the operation,
* but it is not normally necessary to connect to any signals,
* except for one case: when the supported actions include
- * %GDK_DRAG_MOVE, you need to listen for the
+ * %GDK_ACTION_MOVE, you need to listen for the
* #GtkDragSource::drag-end signal and delete the
* data after it has been transferred.
*/
* The ::prepare signal is emitted when a drag is about to be initiated.
* It returns the * #GdkContentProvider to use for the drag that is about
* to start. The default handler for this signal returns the value of
- * the #GtkDragSource::content property, so if you set up that property
+ * the #GtkDragSource:content property, so if you set up that property
* ahead of time, you don't need to connect to this signal.
*
* Returns: (transfer full) (nullable): a #GdkContentProvider, or %NULL
/**
* GtkDragSource::drag-begin:
* @source: the #GtkDragSource
- * @drag: the #GtkDrag object
+ * @drag: the #GdkDrag object
*
* The ::drag-begin signal is emitted on the drag source when a drag
* is started. It can be used to e.g. set a custom drag icon with
/**
* GtkDragSource::drag-end:
* @source: the #GtkDragSource
- * @drag: the #GtkDrag object
+ * @drag: the #GdkDrag object
* @delete_data: %TRUE if the drag was performing %GDK_ACTION_MOVE,
* and the data should be deleted
*
/**
* GtkDragSource::drag-cancel:
* @source: the #GtkDragSource
- * @drag: the #GtkDrag object
+ * @drag: the #GdkDrag object
* @reason: information on why the drag failed
*
* The ::drag-cancel signal is emitted on the drag source when a drag has
*
* Gets the current content provider of a #GtkDragSource.
*
- * Returns: (transfer none): the #GtkContentProvider of @source
+ * Returns: (transfer none): the #GdkContentProvider of @source
*/
GdkContentProvider *
gtk_drag_source_get_content (GtkDragSource *source)
{
g_return_val_if_fail (GTK_IS_DRAG_SOURCE (source), NULL);
- return source->content;
+ return source->content;
}
/**
* gtk_drag_source_set_content:
* @source: a #GtkDragSource
- * @content: (nullable): a #GtkContentProvider, or %NULL
+ * @content: (nullable): a #GdkContentProvider, or %NULL
*
* Sets a content provider on a #GtkDragSource.
*
* or in a handler for the #GtkDragSource::prepare signal.
*
* You may consider setting the content provider back to
- * %NULL in a #GTkDragSource::drag-end signal handler.
+ * %NULL in a #GtkDragSource::drag-end signal handler.
*/
void
gtk_drag_source_set_content (GtkDragSource *source,
* During a DND operation, the actions are offered
* to potential drop targets. If @actions include
* %GDK_ACTION_MOVE, you need to listen to the
- * #GtkDraGSource::drag-end signal and handle
+ * #GtkDragSource::drag-end signal and handle
* @delete_data being %TRUE.
*
* This function can be called before a drag is started,
/**
* gtk_drag_source_set_icon:
* @source: a #GtkDragSource
- * @paintable: (nullable): the #GtkPaintable to use as icon, or %NULL
+ * @paintable: (nullable): the #GdkPaintable to use as icon, or %NULL
* @hot_x: the hotspot X coordinate on the icon
* @hot_y: the hotspot Y coordinate on the icon
*
* gtk_drag_source_get_drag:
* @source: a #GtkDragSource
*
- * Returns the underlying #GtkDrag object for an ongoing drag.
+ * Returns the underlying #GdkDrag object for an ongoing drag.
*
* Returns: (nullable) (transfer none): the #GdkDrag of the current drag operation, or %NULL
*/
g_object_class_install_properties (object_class, NUM_PROPERTIES, properties);
/**
- * GtkWidget::accept:
+ * GtkDropTargetAsync::accept:
* @self: the #GtkDropTargetAsync
* @drop: the #GdkDrop
*
* ]|
*
* You don't need to provide any other vfuncs. The default implementations
- * work by forwarding to the delegate that the get_delegate() vfunc returns.
+ * work by forwarding to the delegate that the #GtkEditableInterface.get_delegate()
+ * vfunc returns.
*
* In your instance_init function, create your text widget, and then call
* gtk_editable_init_delegate():
* The #GtkEmojiChooser popover is used by text widgets such as #GtkEntry or
* #GtkTextView to offer users a convenient way to insert Emoji characters.
*
- * GtkEmojiChooser emits the #GtkEmojiChooser:emoji-picked signal when an
+ * GtkEmojiChooser emits the #GtkEmojiChooser::emoji-picked signal when an
* Emoji is selected.
*
* # CSS nodes
*
* Creates a new #GtkEmojiChooser.
*
- * Returns: a new #GtkEmojiChoser
+ * Returns: a new #GtkEmojiChooser
*/
GtkWidget *
gtk_emoji_chooser_new (void)
* @parent_class: The parent class.
* @activate: Class handler for the #GtkEntry::activate signal. The default
* implementation activates the gtk.activate-default action.
- * @move_cursor: Class handler for the #GtkEntry::move-cursor signal. The
- * default implementation specifies the standard #GtkEntry cursor movement
- * behavior.
- * @insert_at_cursor: Class handler for the #GtkEntry::insert-at-cursor signal.
- * The default implementation inserts text at the cursor.
- * @delete_from_cursor: Class handler for the #GtkEntry::delete-from-cursor
- * signal. The default implementation deletes the selection or the specified
- * number of characters or words.
- * @backspace: Class handler for the #GtkEntry::backspace signal. The default
- * implementation deletes the selection or a single character or word.
- * @cut_clipboard: Class handler for the #GtkEntry::cut-clipboard signal. The
- * default implementation cuts the selection, if one exists.
- * @copy_clipboard: Class handler for the #GtkEntry::copy-clipboard signal. The
- * default implementation copies the selection, if one exists.
- * @paste_clipboard: Class handler for the #GtkEntry::paste-clipboard signal.
- * The default implementation pastes at the current cursor position or over
- * the current selection if one exists.
- * @toggle_overwrite: Class handler for the #GtkEntry::toggle-overwrite signal.
- * The default implementation toggles overwrite mode and blinks the cursor.
- * @insert_emoji: Class handler for the #GtkEntry::insert-emoji signal.
*
* Class structure for #GtkEntry. All virtual functions have a default
* implementation. Derived classes may set the virtual function pointers for the
* GtkPickFlags:
* @GTK_PICK_DEFAULT: The default behavior, include widgets that are receiving events
* @GTK_PICK_INSENSITIVE: Include widgets that are insensitive
- * @GTK_PICK_NON_TARGETABLE: Include widgets that are marked as non-targetable. See #GtkWidget::can-target
+ * @GTK_PICK_NON_TARGETABLE: Include widgets that are marked as non-targetable. See #GtkWidget:can-target
*
* Flags that influence the behavior of gtk_widget_pick()
*/
* @controller: a #GtkEventController
*
* Resets the @controller to a clean state. Every interaction
- * the controller did through gtk_event_controll_handle_event()
+ * the controller did through gtk_event_controller_handle_event()
* will be dropped at this point.
**/
void
* #GtkEventControllerFocus:contains-focus.
*
* When handling focus events, this property is updated
- * before #GtkEventControllerFocus::focus-in or
- * #GtkEventControllerFocus::focus-out are emitted.
+ * before #GtkEventControllerKey::focus-in or
+ * #GtkEventControllerKey::focus-out are emitted.
*/
props[PROP_IS_FOCUS] =
g_param_spec_boolean ("is-focus",
* or inside a descendent.
*
* When handling focus events, this property is updated
- * before #GtkEventControllerFocus::focus-in or
- * #GtkEventControllerFocus::focus-out are emitted.
+ * before #GtkEventControllerFocus::enter or
+ * #GtkEventControllerFocus::leave are emitted.
*/
props[PROP_CONTAINS_FOCUS] =
g_param_spec_boolean ("contains-focus",
*
* The controller can be set up to emit motion for either/both vertical
* and horizontal scroll events through #GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
- * #GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and #GTK_EVENT_CONTROLLER_SCROLL_BOTH.
+ * #GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and #GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
* If any axis is disabled, the respective #GtkEventControllerScroll::scroll
* delta will be 0. Vertical scroll events will be translated to horizontal
* motion for the devices incapable of horizontal scrolling.
* in the file chooser
* @mime_type: the mime type of the file
*
- * A #GtkFileFilterInfo-struct is used to pass information about the
+ * A #GtkFileFilterInfo is used to pass information about the
* tested file to gtk_file_filter_filter().
*/
struct _GtkFileFilterInfo
/**
* GtkFlattenListModel:item-type:
*
- * The #GTpe for elements of this object
+ * The #GType for elements of this object
*/
properties[PROP_ITEM_TYPE] =
g_param_spec_gtype ("item-type",
* @model: (nullable) (transfer none): the new model or %NULL
*
* Sets a new model to be flattened. The model must contain items of
- * #GtkListModel that conform to the item type of @self.
+ * #GListModel that conform to the item type of @self.
**/
void
gtk_flatten_list_model_set_model (GtkFlattenListModel *self,
* By default, GTK+ will limit rate of input events. On stylus input where
* accuracy of strokes is paramount, this function returns the accumulated
* coordinate/timing state before the emission of the current
- * #GtkGestureStylus:motion signal.
+ * #GtkGestureStylus::motion signal.
*
* This function may only be called within a #GtkGestureStylus::motion
* signal handler, the state given in this signal and obtainable through
* @flags: flags modifying the behavior of the icon lookup
*
* Looks up a named icon for a desired size and window scale, returning a
- * #GtkIcon. The icon can then be rendered by using it as a #GdkPaintable,
+ * #GtkIconPaintable. The icon can then be rendered by using it as a #GdkPaintable,
* or you can get information such as the filename and size.
*
* If the available @icon_name is not available and @fallbacks are provided,
*
* Note that you probably want to listen for icon theme changes and
* update the icon. This is usually done by overriding the
- * #GtkWidget:css-changed function.
+ * #GtkWidgetClass.css-changed() function.
*
* Returns: (transfer full): a #GtkIconPaintable object
* containing the icon.
}
/*
- * GtkIcon
+ * GtkIconPaintable
*/
static void icon_paintable_init (GdkPaintableInterface *iface);
/**
* gtk_icon_paintable_get_file:
- * @self: a #GtkIcon
+ * @self: a #GtkIconPaintable
*
* Gets the #GFile that was used to load the icon, or %NULL if the icon was
* not loaded from a file.
/**
* gtk_icon_paintable_get_icon_name:
- * @self: a #GtkIcon
+ * @self: a #GtkIconPaintable
*
* Get the icon name being used for this icon.
*
* When an icon looked up in the icon theme was not available, the
* icon theme may use fallback icons - either those specified to
- * gtk_icon_theme_lookup() or the always-available
+ * gtk_icon_theme_lookup_icon() or the always-available
* "image-missing". The icon chosen is returned by this function.
*
* If the icon was created without an icon theme, this function returns %NULL.
/**
* gtk_icon_paintable_is_symbolic:
- * @self: a #GtkIcon
+ * @self: a #GtkIconPaintable
*
* Checks if the icon is symbolic or not. This currently uses only
* the file name and not the file contents for determining this.
/**
* gtk_icon_paintable_snapshot_with_colors:
- * @icon: a #GtkIcon
+ * @icon: a #GtkIconPaintable
* @snapshot: a #GdkSnapshot to snapshot to
* @width: width to snapshot in
* @height: height to snapshot in
* @scale: the desired scale
*
* Creates a #GtkIconPaintable for a file with a given size and scale
- * #GtkIcon. The icon can then be rendered by using it as a #GdkPaintable.
+ * #GtkIconPaintable. The icon can then be rendered by using it as a #GdkPaintable.
*
* Returns: (transfer full): a #GtkIconPaintable containing
* for the icon. Unref with g_object_unref()
* @flags: flags modifying the behavior of the icon lookup
*
* Looks up a icon for a desired size and window scale, returning a
- * #GtkIcon. The icon can then be rendered by using it as a #GdkPaintable,
+ * #GtkIconPaintable. The icon can then be rendered by using it as a #GdkPaintable,
* or you can get information such as the filename and size.
*
* Returns: (transfer full): a #GtkIconPaintable containing
* pixbuf; you still need to unref it if you own references.
* #GtkImage will add its own reference rather than adopting yours.
*
- * This is a helper for gtk_image_new_from_texture(), and you can't
+ * This is a helper for gtk_image_new_from_paintable(), and you can't
* get back the exact pixbuf once this is called, only a texture.
*
* Note that this function just creates an #GtkImage from the pixbuf. The
* ]|
*
* GtkListBox uses a single CSS node named list. It may carry the .separators style
- * class, when the #GtkListBox::show-separators property is set. Each GtkListBoxRow uses
+ * class, when the #GtkListBox:show-separators property is set. Each GtkListBoxRow uses
* a single CSS node named row. The row nodes get the .activatable
* style class added when appropriate.
*/
* toolkit and parses some standard command line options.
*
* If you are using #GtkApplication, you don't have to call gtk_init()
- * or gtk_init_check(); the #GtkApplication::startup handler
+ * or gtk_init_check(); the #GApplication::startup handler
* does it for you.
*
* This function will terminate your program if it was unable to
/**
* gtk_mount_operation_set_display:
* @op: a #GtkMountOperation
- * @display: a #Gdk
+ * @display: a #GdkDisplay
*
* Sets the display to show windows of the #GtkMountOperation on.
*/
* @widget: an overlay child of #GtkOverlay
* @clip_overlay: whether the child should be clipped
*
- * Convenience function to set the value of the #GtkOverlay:clip-overlay
- * child property for @widget.
+ * Sets whether @widget should be clipped within the parent.
*/
void
gtk_overlay_set_clip_overlay (GtkOverlay *overlay,
* @overlay: a #GtkOverlay
* @widget: an overlay child of #GtkOverlay
*
- * Convenience function to get the value of the #GtkOverlay:clip-overlay
- * child property for @widget.
+ * Gets whether @widget should be clipped within the parent.
*
* Returns: whether the widget is clipped within the parent.
*/
* isn’t found or can’t be loaded, the resulting #GtkPicture be empty.
*
* If you need to detect failures to load the file, use
- * gdk_texture_new_for_file() to load the file yourself, then create
+ * gdk_texture_new_from_file() to load the file yourself, then create
* the #GtkPicture from the texture.
*
* Returns: a new #GtkPicture
*
* Menu items will also show accelerators, which are usually associated
* with actions via gtk_application_set_accels_for_action(),
- * gtk_widget_add_binding_action() or gtk_shortcut_controller_add_shortcut().
+ * gtk_widget_class_add_binding_action() or gtk_shortcut_controller_add_shortcut().
*
* # CSS Nodes
*
/**
* gtk_popover_menu_set_menu_model:
* @popover: a #GtkPopoverMenu
- * @model: (nullable): a #GtkMenuModel, or %NULL
+ * @model: (nullable): a #GMenuModel, or %NULL
*
* Sets a new menu model on @popover.
*
* ]|
*
* In order to retrieve the list of recently used files, you can use
- * gtk_recent_manager_get_items(), which returns a list of #GtkRecentInfo-structs.
+ * gtk_recent_manager_get_items(), which returns a list of #GtkRecentInfo.
*
* A #GtkRecentManager is the model used to populate the contents of
* one, or more #GtkRecentChooser implementations.
/**
* GtkRecentInfo:
*
- * #GtkRecentInfo-struct contains private data only, and should
- * be accessed using the provided API.
+ * #GtkRecentInfo contains private data only, and should be accessed using the
+ * provided API.
*
- * #GtkRecentInfo constains all the meta-data
+ * #GtkRecentInfo contains all the meta-data
* associated with an entry in the recently used files list.
*/
struct _GtkRecentInfo
*
* Adds a new resource, pointed by @uri, into the recently used
* resources list, using the metadata specified inside the
- * #GtkRecentData-struct passed in @recent_data.
+ * #GtkRecentData passed in @recent_data.
*
* The passed URI will be used to identify this resource inside the
* list.
*
* In order to register the new recently used resource, metadata about
* the resource must be passed as well as the URI; the metadata is
- * stored in a #GtkRecentData-struct, which must contain the MIME
+ * stored in a #GtkRecentData, which must contain the MIME
* type of the resource pointed by the URI; the name of the application
* that is registering the item, and a command line to be used when
* launching the item.
*
- * Optionally, a #GtkRecentData-struct might contain a UTF-8 string
+ * Optionally, a #GtkRecentData might contain a UTF-8 string
* to be used when viewing the item instead of the last component of
* the URI; a short description of the item; whether the item should
* be considered private - that is, should be displayed only by the
* @error: (allow-none): a return location for a #GError, or %NULL
*
* Searches for a URI inside the recently used resources list, and
- * returns a #GtkRecentInfo-struct containing informations about the resource
+ * returns a #GtkRecentInfo containing informations about the resource
* like its MIME type, or its display name.
*
- * Returns: (nullable): a #GtkRecentInfo-struct containing information
+ * Returns: (nullable): a #GtkRecentInfo containing information
* about the resource pointed by @uri, or %NULL if the URI was
* not registered in the recently used resources list. Free with
* gtk_recent_info_unref().
* @info_a: a #GtkRecentInfo
* @info_b: a #GtkRecentInfo
*
- * Checks whether two #GtkRecentInfo-struct point to the same
- * resource.
+ * Checks whether two #GtkRecentInfo point to the same resource.
*
- * Returns: %TRUE if both #GtkRecentInfo-struct point to the same
+ * Returns: %TRUE if both #GtkRecentInfo point to the same
* resource, %FALSE otherwise
*/
gboolean
* gtk_bin_get_child (GTK_BIN (scrolled_window)));
* ]|
*
- * Unless #GtkScrolledWindow:hscrolbar-policy and #GtkScrolledWindow:vscrollbar-policy
+ * Unless #GtkScrolledWindow:hscrollbar-policy and #GtkScrolledWindow:vscrollbar-policy
* are GTK_POLICY_NEVER or GTK_POLICY_EXTERNAL,
* GtkScrolledWindow adds internal #GtkScrollbar widgets around its child. The
* scroll position of the child, and if applicable the scrollbars, is controlled
* as narrow indicators.
*
* Note that overlay scrolling can also be globally disabled, with
- * the #GtkSettings::gtk-overlay-scrolling setting.
+ * the #GtkSettings:gtk-overlay-scrolling setting.
*/
properties[PROP_OVERLAY_SCROLLING] =
g_param_spec_boolean ("overlay-scrolling",
* - #GtkSignalAction: a shortcut action that emits a given signal
* - #GtkActivateAction: a shortcut action that calls gtk_widget_activate()
* - #GtkNamedAction: a shortcut action that calls gtk_widget_activate_action()
-* - #GtkGActionAction: a shortcut action that activates a given #GAction
* - #GtkNothingAction: a shortcut action that does nothing
*
* # GtkShortcutAction as GtkBuildable
* of type %GTK_SHORTCUT_ACCELERATOR, then GTK+ will use
* the accelerators that are associated with the action
* via gtk_application_set_accels_for_action(), and setting
- * #GtkShortcutsShortcut::accelerator is not necessary.
+ * #GtkShortcutsShortcut:accelerator is not necessary.
*/
properties[PROP_ACTION_NAME] =
g_param_spec_string ("action-name",
* - `mailto:me@gnome.org`
*
* The @callback will be called when the launch is completed.
- * It should call gtk_show_uri_finish() to obtain the result.
+ * It should call gtk_show_uri_full_finish() to obtain the result.
*
* This is the recommended call to be used as it passes information
* necessary for sandbox helpers to parent their dialogs properly.
/**
* gtk_show_uri_full_finish:
* @parent: the #GtkWindow passed to gtk_show_uri()
- * @result: #GASyncResult that was passed to @callback
+ * @result: #GAsyncResult that was passed to @callback
* @error: return location for an error
*
* Finished the gtk_show_uri() call and returns the result
* @Title: GtkSnapshot
*
* GtkSnapshot is an auxiliary object that assists in creating #GskRenderNodes
- * in the #GtkWidget::snapshot vfunc. It functions in a similar way to
+ * in the #GdkPaintableInterface.snapshot() vfunc. It functions in a similar way to
* a cairo context, and maintains a stack of render nodes and their associated
* transformations.
*
* to change the current node.
*
* The typical way to obtain a GtkSnapshot object is as an argument to
- * the #GtkWidget::snapshot vfunc. If you need to create your own GtkSnapshot,
+ * the #GtkWidgetClass.snapshot() vfunc. If you need to create your own GtkSnapshot,
* use gtk_snapshot_new().
*/
* by @snapshot. After calling this function, it
* is no longer possible to add more nodes to
* @snapshot. The only function that should be
- * called after this is gtk_snapshot_unref().
+ * called after this is g_object_unref().
*
* Returns: (transfer full): the constructed #GskRenderNode
*/
* that was constructed by @snapshot. After calling
* this function, it is no longer possible to add more
* nodes to @snapshot. The only function that should be
- * called after this is gtk_snapshot_unref().
+ * called after this is g_object_unref().
*
* Returns: (transfer full): a new #GdkPaintable
*/
/**
* GtkTextBuffer:can-undo:
*
- * The :can-undo property denotes that the buffer can undo the last
+ * The #GtkTextBuffer:can-undo property denotes that the buffer can undo the last
* applied action.
*/
text_buffer_props[PROP_CAN_UNDO] =
/**
* GtkTextBuffer:can-redo:
*
- * The :can-redo property denotes that the buffer can reapply the
+ * The #GtkTextBuffer:can-redo property denotes that the buffer can reapply the
* last undone action.
*/
text_buffer_props[PROP_CAN_REDO] =
/**
* GtkTextBuffer:enable-undo:
*
- * The :enable-undo property denotes if support for undoing and redoing
- * changes to the buffer is allowed.
+ * The #GtkTextBuffer:enable-undo property denotes if support for undoing and
+ * redoing changes to the buffer is allowed.
*/
text_buffer_props[PROP_ENABLE_UNDO] =
g_param_spec_boolean ("enable-undo",
* @location: position to insert @paintable in @textbuffer
* @paintable: the #GdkPaintable to be inserted
*
- * The ::insert-paintable signal is emitted to insert a #GdkPaintable
+ * The #GtkTextBuffer::insert-paintable signal is emitted to insert a #GdkPaintable
* in a #GtkTextBuffer. Insertion actually occurs in the default handler.
*
* Note that if your handler runs before the default handler it must not
* @location: position to insert @anchor in @textbuffer
* @anchor: the #GtkTextChildAnchor to be inserted
*
- * The ::insert-child-anchor signal is emitted to insert a
+ * The #GtkTextBuffer::insert-child-anchor signal is emitted to insert a
* #GtkTextChildAnchor in a #GtkTextBuffer.
* Insertion actually occurs in the default handler.
*
* @start: the start of the range to be deleted
* @end: the end of the range to be deleted
*
- * The ::delete-range signal is emitted to delete a range
+ * The #GtkTextBuffer::delete-range signal is emitted to delete a range
* from a #GtkTextBuffer.
*
* Note that if your handler runs before the default handler it must not
* GtkTextBuffer::changed:
* @textbuffer: the object which received the signal
*
- * The ::changed signal is emitted when the content of a #GtkTextBuffer
+ * The #GtkTextBuffer::changed signal is emitted when the content of a #GtkTextBuffer
* has changed.
*/
signals[CHANGED] =
* GtkTextBuffer::modified-changed:
* @textbuffer: the object which received the signal
*
- * The ::modified-changed signal is emitted when the modified bit of a
+ * The #GtkTextBuffer::modified-changed signal is emitted when the modified bit of a
* #GtkTextBuffer flips.
*
* See also:
* @location: The location of @mark in @textbuffer
* @mark: The mark that is set
*
- * The ::mark-set signal is emitted as notification
+ * The #GtkTextBuffer::mark-set signal is emitted as notification
* after a #GtkTextMark is set.
*
* See also:
* @textbuffer: the object which received the signal
* @mark: The mark that was deleted
*
- * The ::mark-deleted signal is emitted as notification
+ * The #GtkTextBuffer::mark-deleted signal is emitted as notification
* after a #GtkTextMark is deleted.
*
* See also:
* @start: the start of the range the tag is applied to
* @end: the end of the range the tag is applied to
*
- * The ::apply-tag signal is emitted to apply a tag to a
+ * The #GtkTextBuffer::apply-tag signal is emitted to apply a tag to a
* range of text in a #GtkTextBuffer.
* Applying actually occurs in the default handler.
*
* @start: the start of the range the tag is removed from
* @end: the end of the range the tag is removed from
*
- * The ::remove-tag signal is emitted to remove all occurrences of @tag from
- * a range of text in a #GtkTextBuffer.
+ * The #GtkTextBuffer::remove-tag signal is emitted to remove all occurrences
+ * of @tag from a range of text in a #GtkTextBuffer.
* Removal actually occurs in the default handler.
*
* Note that if your handler runs before the default handler it must not
* GtkTextBuffer::begin-user-action:
* @textbuffer: the object which received the signal
*
- * The ::begin-user-action signal is emitted at the beginning of a single
+ * The #GtkTextBuffer::begin-user-action signal is emitted at the beginning of a single
* user-visible operation on a #GtkTextBuffer.
*
* See also:
* GtkTextBuffer::end-user-action:
* @textbuffer: the object which received the signal
*
- * The ::end-user-action signal is emitted at the end of a single
+ * The #GtkTextBuffer::end-user-action signal is emitted at the end of a single
* user-visible operation on the #GtkTextBuffer.
*
* See also:
*
* Adds @clipboard to the list of clipboards in which the selection
* contents of @buffer are available. In most cases, @clipboard will be
- * the #GdkClipboard returned by gdk_widget_get_primary_clipboard()
+ * the #GdkClipboard returned by gtk_widget_get_primary_clipboard()
* for a view of @buffer.
**/
void
/**
* gtk_text_buffer_begin_irreversible_action:
- * @buffer: a #Gtktextbuffer
+ * @buffer: a #GtkTextBuffer
*
* Denotes the beginning of an action that may not be undone. This will cause
* any previous operations in the undo/redo queue to be cleared.
/**
* gtk_text_buffer_end_irreversible_action:
- * @buffer: a #Gtktextbuffer
+ * @buffer: a #GtkTextBuffer
*
* Denotes the end of an action that may not be undone. This will cause
* any previous operations in the undo/redo queue to be cleared.
* want to turn the cursor off.
*
* Note that this property may be overridden by the
- * #GtkSettings:gtk-keynave-use-caret settings.
+ * #GtkSettings:gtk-keynav-use-caret settings.
*/
void
gtk_text_view_set_cursor_visible (GtkTextView *text_view,
* keybinding signal.
* @cut_clipboard: The class handler for the #GtkTextView::cut-clipboard
* keybinding signal
- * @copy_clipboard: The class handler for the #GtkTextview::copy-clipboard
+ * @copy_clipboard: The class handler for the #GtkTextView::copy-clipboard
* keybinding signal.
* @paste_clipboard: The class handler for the #GtkTextView::paste-clipboard
* keybinding signal.
* the widget (it can be used until the screen for the widget changes
* or the widget is removed from its toplevel), and will be updated to
* match any changes to the widget’s attributes. This can be tracked
- * by using the #GtkWidget::display-changed signal on the widget.
+ * by listening to changes of the #GtkWidget:root property on the widget.
*
* Returns: (transfer none): the #PangoContext for the widget.
**/
*
* If you keep a #PangoLayout created in this way around, you need
* to re-create it when the widget #PangoContext is replaced.
- * This can be tracked by using the #GtkWidget::display-changed signal
+ * This can be tracked by listening to changes of the #GtkWidget:root property
* on the widget.
*
* Returns: (transfer full): the new #PangoLayout
*
* Returns the baseline that has currently been allocated to @widget.
* This function is intended to be used when implementing handlers
- * for the #GtkWidget::snapshot function, and when allocating child
+ * for the #GtkWidgetClass.snapshot() function, and when allocating child
* widgets in #GtkWidget::size_allocate.
*
* Returns: the baseline of the @widget, or -1 if none
* have been made.
*
* When a widget receives a call to the snapshot function, it must send
- * synthetic #GtkWidget::snapshot calls to all children. This function
+ * synthetic #GtkWidgetClass.snapshot() calls to all children. This function
* provides a convenient way of doing this. A widget, when it receives
- * a call to its #GtkWidget::snapshot function, calls
+ * a call to its #GtkWidgetClass.snapshot() function, calls
* gtk_widget_snapshot_child() once for each child, passing in
* the @snapshot the widget received.
*
* redraws accordingly. The default implementation will take care of this for
* all the default CSS properties, so implementations must chain up.
* @system_setting_changed: Emitted when a system setting was changed. Must chain up.
- * @snapshot: Vfunc for gtk_widget_snapshot().
+ * @snapshot: Vfunc called when a new snapshot of the widget has to be taken.
* @contains: Vfunc for gtk_widget_contains().
*/
struct _GtkWidgetClass
* in which case the window will be minimized before it ever appears
* onscreen.
*
- * You can track result of this operation via the #GdkSurface:state
+ * You can track result of this operation via the #GdkToplevel:state
* property.
*/
void
* could minimize it again, or there may not be a window manager in
* which case minimization isn’t possible, etc.
*
- * You can track result of this operation via the #GdkSurface:state
+ * You can track result of this operation via the #GdkToplevel:state
* property.
*/
void
* in which case the window will be maximized when it appears onscreen
* initially.
*
- * You can track the result of this operation via the #GdkSurface:state
+ * You can track the result of this operation via the #GdkToplevel:state
* property, or by listening to notifications on the #GtkWindow:is-maximized
* property.
*/
* managers honor requests to unmaximize. But normally the window will
* end up unmaximized. Just don’t write code that crashes if not.
*
- * You can track the result of this operation via the #GdkSurface:state
+ * You can track the result of this operation via the #GdkToplevel:state
* property, or by listening to notifications on the #GtkWindow:is-maximized
* property.
*/
* windows. But normally the window will end up fullscreen. Just
* don’t write code that crashes if not.
*
- * You can track iconification via the #GdkSurface::state property
+ * You can track iconification via the #GdkToplevel:state property
**/
void
gtk_window_fullscreen (GtkWindow *window)
* Asks to place @window in the fullscreen state. Note that you shouldn't assume
* the window is definitely full screen afterward.
*
- * You can track iconification via the #GdkSurface::state property
+ * You can track iconification via the #GdkToplevel:state property
*/
void
gtk_window_fullscreen_on_monitor (GtkWindow *window,
* windows. But normally the window will end up restored to its normal
* state. Just don’t write code that crashes if not.
*
- * You can track iconification via the #GdkSurface::state property
+ * You can track iconification via the #GdkToplevel:state property
**/
void
gtk_window_unfullscreen (GtkWindow *window)
projects / gtk4.git / commitdiff